home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / Lists.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  5.4 KB  |  307 lines
  1. /*
  2. **    Lists.c
  3. **
  4. **    Generic list management routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14.     /* ClearGenericList(struct GenericList *List):
  15.      *
  16.      *    Clear a generic list, free its contents.
  17.      */
  18.  
  19. VOID
  20. ClearGenericList(struct GenericList *List)
  21. {
  22.     ObtainSemaphore(&List -> ListSemaphore);
  23.  
  24.     FreeList((struct List *)&List -> ListHeader);
  25.  
  26.     List -> ListCount = 0;
  27.  
  28.     ReleaseSemaphore(&List -> ListSemaphore);
  29. }
  30.  
  31.     /* DeleteGenericList(struct GenericList *List):
  32.      *
  33.      *    Free a generic list, including its contents.
  34.      */
  35.  
  36. VOID
  37. DeleteGenericList(struct GenericList *List)
  38. {
  39.     ClearGenericList(List);
  40.  
  41.     FreeVecPooled(List);
  42. }
  43.  
  44.     /* CreateGenericList():
  45.      *
  46.      *    Create a generic list.
  47.      */
  48.  
  49. struct GenericList *
  50. CreateGenericList()
  51. {
  52.     struct GenericList *List;
  53.  
  54.     if(List = (struct GenericList *)AllocVecPooled(sizeof(struct GenericList),MEMF_ANY | MEMF_CLEAR | MEMF_PUBLIC))
  55.     {
  56.         NewList((struct List *)&List -> ListHeader);
  57.  
  58.         InitSemaphore(&List -> ListSemaphore);
  59.  
  60.         List -> ListCount = 0;
  61.     }
  62.  
  63.     return(List);
  64. }
  65.  
  66.     /* FirstGenericListNode(struct GenericList *List):
  67.      *
  68.      *    Pick the first node in a generic list.
  69.      */
  70.  
  71. struct Node *
  72. FirstGenericListNode(struct GenericList *List)
  73. {
  74.     struct Node *Node;
  75.  
  76.     ObtainSemaphore(&List -> ListSemaphore);
  77.  
  78.     if(List -> ListHeader . mlh_Head -> mln_Succ)
  79.         Node = List -> ListNode = (struct Node *)List -> ListHeader . mlh_Head;
  80.     else
  81.         Node = NULL;
  82.  
  83.     ReleaseSemaphore(&List -> ListSemaphore);
  84.  
  85.     return(Node);
  86. }
  87.  
  88.     /* LastGenericListNode(struct GenericList *List):
  89.      *
  90.      *    Pick the last node in a generic list.
  91.      */
  92.  
  93. struct Node *
  94. LastGenericListNode(struct GenericList *List)
  95. {
  96.     struct Node *Node;
  97.  
  98.     ObtainSemaphore(&List -> ListSemaphore);
  99.  
  100.     if(List -> ListHeader . mlh_Head -> mln_Succ)
  101.         Node = List -> ListNode = (struct Node *)List -> ListHeader . mlh_TailPred;
  102.     else
  103.         Node = NULL;
  104.  
  105.     ReleaseSemaphore(&List -> ListSemaphore);
  106.  
  107.     return(Node);
  108. }
  109.  
  110.     /* NextGenericListNode(struct GenericList *List):
  111.      *
  112.      *    Pick the next successive node in a generic list.
  113.      */
  114.  
  115. struct Node *
  116. NextGenericListNode(struct GenericList *List)
  117. {
  118.     struct Node *Node;
  119.  
  120.     ObtainSemaphore(&List -> ListSemaphore);
  121.  
  122.     if(List -> ListNode)
  123.     {
  124.         if(List -> ListNode -> ln_Succ -> ln_Succ)
  125.             Node = List -> ListNode = List -> ListNode -> ln_Succ;
  126.         else
  127.             Node = NULL;
  128.  
  129.         ReleaseSemaphore(&List -> ListSemaphore);
  130.     }
  131.     else
  132.     {
  133.         ReleaseSemaphore(&List -> ListSemaphore);
  134.  
  135.         Node = FirstGenericListNode(List);
  136.     }
  137.  
  138.     return(Node);
  139. }
  140.  
  141.     /* PrevGenericListNode(struct GenericList *List):
  142.      *
  143.      *    Pick the preceding node in a generic list.
  144.      */
  145.  
  146. struct Node *
  147. PrevGenericListNode(struct GenericList *List)
  148. {
  149.     struct Node *Node;
  150.  
  151.     ObtainSemaphore(&List -> ListSemaphore);
  152.  
  153.     if(List -> ListNode)
  154.     {
  155.         if(List -> ListNode -> ln_Pred -> ln_Pred)
  156.             Node = List -> ListNode = List -> ListNode -> ln_Pred;
  157.         else
  158.             Node = NULL;
  159.  
  160.         ReleaseSemaphore(&List -> ListSemaphore);
  161.     }
  162.     else
  163.     {
  164.         ReleaseSemaphore(&List -> ListSemaphore);
  165.  
  166.         Node = LastGenericListNode(List);
  167.     }
  168.  
  169.     return(Node);
  170. }
  171.  
  172.     /* DeleteGenericListNode(struct GenericList *List,struct Node *Node):
  173.      *
  174.      *    Delete a single node from a generic list.
  175.      */
  176.  
  177. VOID
  178. DeleteGenericListNode(struct GenericList *List,struct Node *Node)
  179. {
  180.     ObtainSemaphore(&List -> ListSemaphore);
  181.  
  182.     if(!Node)
  183.         Node = List -> ListNode;
  184.  
  185.     if(Node)
  186.     {
  187.         if(Node == List -> ListNode)
  188.         {
  189.             if(Node -> ln_Succ -> ln_Succ)
  190.                 List -> ListNode = Node -> ln_Succ;
  191.             else
  192.             {
  193.                 if(Node -> ln_Pred -> ln_Pred)
  194.                     List -> ListNode = Node -> ln_Pred;
  195.                 else
  196.                     List -> ListNode = NULL;
  197.             }
  198.         }
  199.  
  200.         FreeNode(Node);
  201.  
  202.         List -> ListCount--;
  203.     }
  204.  
  205.     ReleaseSemaphore(&List -> ListSemaphore);
  206. }
  207.  
  208.     /* CreateGenericListNode(LONG Size,STRPTR Name):
  209.      *
  210.      *    Create a new generic list node.
  211.      */
  212.  
  213. struct Node *
  214. CreateGenericListNode(LONG Size,STRPTR Name)
  215. {
  216.     struct Node    *Node;
  217.     LONG         Head;
  218.  
  219.     if(Size < sizeof(struct Node))
  220.         Head = Size = sizeof(struct Node);
  221.     else
  222.         Head = Size;
  223.  
  224.     if(Name)
  225.         Size += strlen(Name) + 1;
  226.  
  227.     if(Node = (struct Node *)AllocVecPooled(Size,MEMF_ANY | MEMF_CLEAR | MEMF_PUBLIC))
  228.     {
  229.         if(Name)
  230.         {
  231.             Node -> ln_Name = ((char *)Node) + Head;
  232.  
  233.             strcpy(Node -> ln_Name,Name);
  234.         }
  235.         else
  236.             Node -> ln_Name = NULL;
  237.     }
  238.  
  239.     return(Node);
  240. }
  241.  
  242.     /* AddGenericListNode(struct GenericList *List,struct Node *Node,BYTE Mode):
  243.      *
  244.      *    Add a node to a generic list.
  245.      */
  246.  
  247. VOID
  248. AddGenericListNode(struct GenericList *List,struct Node *Node,LONG Mode)
  249. {
  250.     ObtainSemaphore(&List -> ListSemaphore);
  251.  
  252.     switch(Mode)
  253.     {
  254.         case ADD_GLIST_BOTTOM:
  255.  
  256.             AddTail((struct List *)&List -> ListHeader,Node);
  257.             break;
  258.  
  259.         case ADD_GLIST_TOP:
  260.  
  261.             AddHead((struct List *)&List -> ListHeader,Node);
  262.             break;
  263.  
  264.         case ADD_GLIST_BEHIND:
  265.  
  266.             if(List -> ListNode)
  267.                 Insert((struct List *)&List -> ListHeader,Node,List -> ListNode);
  268.             else
  269.                 AddTail((struct List *)&List -> ListHeader,Node);
  270.  
  271.             break;
  272.  
  273.         case ADD_GLIST_BEFORE:
  274.  
  275.             if(List -> ListNode && List -> ListNode != (struct Node *)List -> ListHeader . mlh_Head)
  276.                 Insert((struct List *)&List -> ListHeader,Node,List -> ListNode -> ln_Pred);
  277.             else
  278.                 AddHead((struct List *)&List -> ListHeader,Node);
  279.  
  280.             break;
  281.     }
  282.  
  283.     List -> ListNode = Node;
  284.     List -> ListCount++;
  285.  
  286.     ReleaseSemaphore(&List -> ListSemaphore);
  287. }
  288.  
  289.     /* GenericListCount(struct GenericList *List):
  290.      *
  291.      *    Return the number of generic list entries.
  292.      */
  293.  
  294. LONG
  295. GenericListCount(struct GenericList *List)
  296. {
  297.     LONG Count;
  298.  
  299.     ObtainSemaphore(&List -> ListSemaphore);
  300.  
  301.     Count = List -> ListCount;
  302.  
  303.     ReleaseSemaphore(&List -> ListSemaphore);
  304.  
  305.     return(Count);
  306. }
  307.